/**
 * 腾讯云ASR专用日志工具
 * 用于记录和分析语音识别过程中的各种信息
 */
const logger = require('../logger');
const { v4: uuidv4 } = require('../../lib/uuid');

/**
 * ASR日志配置
 */
const config = {
    // 日志存储键名（使用本地存储）
    storageKey: 'ASR_LOGS_STORAGE_KEY',

    // 日志级别: debug, info, warn, error
    level: 'debug',

    // 是否启用日志
    enabled: true,

    // 最大日志条数
    maxLogs: 1000,

    // 每次获取的默认日志数量
    defaultLimit: 100
};

/**
 * 日志条目格式
 * @typedef {Object} LogEntry
 * @property {string} timestamp - 时间戳
 * @property {string} level - 日志级别 (debug, info, warn, error)
 * @property {string} message - 日志消息
 * @property {string} [requestId] - 请求ID
 * @property {string} [category] - 日志类别
 * @property {Object} [details] - 额外信息
 */

/**
 * 内存中的日志缓存，避免频繁本地存储读写
 * @type {Array<LogEntry>}
 */
let logsCache = [];

/**
 * 是否已初始化
 * @type {boolean}
 */
let initialized = false;

/**
 * ASR日志工具
 */
const asrLogger = {
    /**
     * 初始化ASR日志模块
     * @param {Object} options - 配置选项
     */
    init(options = {}) {
        // 合并配置
        Object.assign(config, options);

        // 从本地存储加载日志
        this.loadLogs();

        initialized = true;

        // 记录初始化日志
        this.debug('ASR日志模块初始化', {
            config: {
                level: config.level,
                enabled: config.enabled,
                maxLogs: config.maxLogs
            }
        });
    },

    /**
     * 从本地存储加载日志
     * @private
     */
    loadLogs() {
        try {
            const logs = wx.getStorageSync(config.storageKey);
            if (logs && Array.isArray(logs)) {
                logsCache = logs;
                // 限制日志数量
                if (logsCache.length > config.maxLogs) {
                    logsCache = logsCache.slice(-config.maxLogs);
                    this.saveLogs();
                }
            }
        } catch (error) {
            // 读取失败则使用空数组
            logsCache = [];
            console.error('ASR日志读取失败:', error);
        }
    },

    /**
     * 保存日志到本地存储
     * @private
     */
    saveLogs() {
        if (!config.enabled) return;

        try {
            // 保留最新的maxLogs条日志
            const logs = logsCache.slice(-config.maxLogs);
            wx.setStorageSync(config.storageKey, logs);
        } catch (error) {
            console.error('ASR日志保存失败:', error);
        }
    },

    /**
     * 添加日志条目
     * @param {string} level - 日志级别
     * @param {string|Object} requestIdOrMessage - 请求ID或消息内容
     * @param {string|Object} [messageOrDetails] - 消息内容或详情
     * @param {Object} [details] - 详情对象
     * @private
     */
    log(level, requestIdOrMessage, messageOrDetails, details) {
        if (!config.enabled) return;

        // 确保已初始化
        if (!initialized) {
            this.init();
        }

        // 处理参数变化
        let requestId, message;

        if (typeof requestIdOrMessage === 'string' && requestIdOrMessage.length > 8 &&
            (requestIdOrMessage.includes('-') || /^[0-9a-f]+$/.test(requestIdOrMessage))) {
            // 第一个参数是请求ID
            requestId = requestIdOrMessage;

            if (typeof messageOrDetails === 'string') {
                // 第二个参数是消息
                message = messageOrDetails;
            } else {
                // 第二个参数是详情
                message = 'ASR操作';
                details = messageOrDetails;
            }
        } else {
            // 第一个参数是消息
            requestId = '';
            message = requestIdOrMessage;
            details = messageOrDetails;
        }

        // 创建日志条目
        const entry = {
            timestamp: Date.now(),
            level,
            message: message || 'ASR操作',
            requestId,
            details: details || {}
        };

        // 添加到缓存
        logsCache.push(entry);

        // 同时记录到通用日志
        logger[level](`[ASR] ${entry.message}`, entry.details);

        // 定期保存到本地存储
        if (logsCache.length % 10 === 0) {
            this.saveLogs();
        }
    },

    /**
     * 记录调试信息
     * @param {string|Object} requestIdOrMessage - 请求ID或消息内容
     * @param {string|Object} [messageOrDetails] - 消息内容或详情
     * @param {Object} [details] - 详情对象
     */
    debug(requestIdOrMessage, messageOrDetails, details) {
        this.log('debug', requestIdOrMessage, messageOrDetails, details);
    },

    /**
     * 记录一般信息
     * @param {string|Object} requestIdOrMessage - 请求ID或消息内容
     * @param {string|Object} [messageOrDetails] - 消息内容或详情
     * @param {Object} [details] - 详情对象
     */
    info(requestIdOrMessage, messageOrDetails, details) {
        this.log('info', requestIdOrMessage, messageOrDetails, details);
    },

    /**
     * 记录警告信息
     * @param {string|Object} requestIdOrMessage - 请求ID或消息内容
     * @param {string|Object} [messageOrDetails] - 消息内容或详情
     * @param {Object} [details] - 详情对象
     */
    warn(requestIdOrMessage, messageOrDetails, details) {
        this.log('warn', requestIdOrMessage, messageOrDetails, details);
    },

    /**
     * 记录错误信息
     * @param {string|Object} requestIdOrMessage - 请求ID或消息内容
     * @param {string|Object} [messageOrDetails] - 消息内容或详情
     * @param {Object} [details] - 详情对象
     */
    error(requestIdOrMessage, messageOrDetails, details) {
        this.log('error', requestIdOrMessage, messageOrDetails, details);
    },

    /**
     * 记录API请求信息
     * @param {string} requestId - 请求ID
     * @param {Object} requestInfo - 请求信息
     */
    logRequest(requestId, requestInfo) {
        const entry = {
            timestamp: Date.now(),
            level: 'info',
            category: 'request',
            message: '发送ASR请求',
            requestId: requestId || uuidv4(),
            details: requestInfo || {}
        };

        logsCache.push(entry);
        logger.info(`[ASR] 发送请求: ${entry.requestId}`, entry.details);
    },

    /**
     * 记录API响应信息
     * @param {string} requestId - 请求ID
     * @param {Object} responseInfo - 响应信息
     */
    logResponse(requestId, responseInfo) {
        const entry = {
            timestamp: Date.now(),
            level: responseInfo.isSuccess ? 'info' : 'warn',
            category: 'response',
            message: `接收ASR响应${responseInfo.isSuccess ? '成功' : '失败'}`,
            requestId: requestId || '',
            details: responseInfo || {}
        };

        logsCache.push(entry);

        if (responseInfo.isSuccess) {
            logger.info(`[ASR] 响应成功: ${entry.requestId}`, entry.details);
        } else {
            logger.warn(`[ASR] 响应失败: ${entry.requestId}`, entry.details);
        }
    },

    /**
     * 记录识别结果
     * @param {string} requestId - 请求ID
     * @param {string} recognizedText - 识别文本
     * @param {number} [responseTime] - 响应时间戳
     */
    logRecognitionResult(requestId, recognizedText, responseTime) {
        const entry = {
            timestamp: Date.now(),
            level: 'info',
            category: 'recognition',
            message: '语音识别结果',
            requestId: requestId || '',
            details: {
                text: recognizedText,
                length: recognizedText.length,
                responseTime: responseTime || Date.now()
            }
        };

        logsCache.push(entry);
        logger.info(`[ASR] 识别结果: ${entry.requestId}`, entry.details);
    },

    /**
     * 记录关键词提取结果
     * @param {string} text - 原始文本
     * @param {string} keyword - 提取的关键词
     */
    logKeywords(text, keyword) {
        const entry = {
            timestamp: Date.now(),
            level: 'info',
            category: 'keywords',
            message: '关键词提取结果',
            details: {
                originalText: text,
                keyword: keyword,
                originalLength: text ? text.length : 0,
                keywordLength: keyword ? keyword.length : 0
            }
        };

        logsCache.push(entry);
        logger.info('[ASR] 关键词提取', entry.details);
    },

    /**
     * 记录音频信息
     * @param {string} filePath - 音频文件路径
     * @param {number|string} duration - 音频时长
     * @param {number} fileSize - 文件大小
     */
    logAudioInfo(filePath, duration, fileSize) {
        const entry = {
            timestamp: Date.now(),
            level: 'info',
            category: 'audio',
            message: '音频文件信息',
            details: {
                filePath,
                duration,
                fileSize,
                format: filePath ? filePath.substring(filePath.lastIndexOf('.') + 1) : 'unknown'
            }
        };

        logsCache.push(entry);
        logger.info('[ASR] 音频信息', entry.details);
    },

    /**
     * 获取ASR日志
     * @param {number} limit - 最大条数
     * @returns {Array<LogEntry>} 日志记录数组
     */
    getLogs(limit = config.defaultLimit) {
        // 获取最近的日志，按时间倒序
        return [...logsCache]
            .sort((a, b) => b.timestamp - a.timestamp)
            .slice(0, limit);
    },

    /**
     * 清空ASR日志
     */
    clearLogs() {
        logsCache = [];
        try {
            wx.removeStorageSync(config.storageKey);
        } catch (error) {
            console.error('清除ASR日志失败:', error);
        }
    }
};

module.exports = asrLogger; 